const { PresetFile, User } = require('../models');
const path = require('path');
const fs = require('fs');
const config = require('../config');

/**
 * 获取所有预设文件
 */
exports.getAllPresetFiles = async (req, res) => {
  try {
    const { active } = req.query;
    
    // 获取数据库对象
    const db = req.app.get('db');
    
    // 如果数据库模型不可用，返回空数组
    if (!db || !db.PresetFile) {
      console.error('数据库模型不可用，返回空预设文件列表');
      return res.json([]);
    }
    
    // 构建查询条件
    const whereClause = {};
    
    // 如果设置了active参数，则根据active参数过滤
    if (active !== undefined) {
      whereClause.isActive = active === 'true';
    }
    
    try {
      const presetFiles = await db.PresetFile.findAll({
        where: whereClause,
        include: [
          {
            model: db.User,
            as: 'creator',
            attributes: ['id', 'username', 'fullName']
          }
        ],
        order: [['createdAt', 'DESC']]
      });
      
      res.json(presetFiles);
    } catch (dbError) {
      console.error('数据库查询失败:', dbError);
      // 返回空数组，而不是抛出错误
      return res.json([]);
    }
  } catch (error) {
    console.error('获取预设文件列表出错:', error);
    res.status(500).json({ message: '服务器内部错误', error: error.message });
  }
};

/**
 * 获取单个预设文件
 */
exports.getPresetFile = async (req, res) => {
  try {
    const { id } = req.params;
    
    // 获取数据库对象
    const db = req.app.get('db');
    
    // 如果数据库模型不可用，返回404
    if (!db || !db.PresetFile) {
      console.error('数据库模型不可用');
      return res.status(404).json({ message: '预设文件不存在' });
    }
    
    const presetFile = await db.PresetFile.findByPk(id, {
      include: [
        {
          model: db.User,
          as: 'creator',
          attributes: ['id', 'username', 'fullName']
        }
      ]
    });
    
    if (!presetFile) {
      return res.status(404).json({ message: '预设文件不存在' });
    }
    
    res.json(presetFile);
  } catch (error) {
    console.error('获取预设文件出错:', error);
    res.status(500).json({ message: '服务器内部错误', error: error.message });
  }
};

/**
 * 上传预设文件
 */
exports.uploadPresetFile = async (req, res) => {
  try {
    // 确保文件已上传
    if (!req.file) {
      return res.status(400).json({ message: '未提供文件' });
    }
    
    const { name, description, category } = req.body;
    
    if (!name) {
      // 删除临时文件
      fs.unlinkSync(req.file.path);
      return res.status(400).json({ message: '文件名称是必须的' });
    }
    
    // 获取数据库对象
    const db = req.app.get('db');
    
    // 如果数据库模型不可用，返回错误并删除临时文件
    if (!db || !db.PresetFile || !db.User) {
      console.error('数据库模型不可用');
      if (req.file && req.file.path && fs.existsSync(req.file.path)) {
        fs.unlinkSync(req.file.path);
      }
      return res.status(500).json({ message: '服务器内部错误，数据库不可用' });
    }
    
    // 获取文件类型
    const fileExtension = path.extname(req.file.originalname).toLowerCase();
    let fileType = 'other'; // 默认为其他类型
    
    // 确定文件类型
    if (['.jpg', '.jpeg', '.png', '.gif', '.webp'].includes(fileExtension)) {
      fileType = 'image';
    } else if (['.doc', '.docx', '.pdf', '.txt', '.xls', '.xlsx', '.ppt', '.pptx'].includes(fileExtension)) {
      fileType = 'document';
    } else if (['.mp4', '.avi', '.mov', '.wmv'].includes(fileExtension)) {
      fileType = 'video';
    } else if (['.mp3', '.wav', '.ogg'].includes(fileExtension)) {
      fileType = 'audio';
    }
    
    // 创建上传文件夹（如果不存在）
    const uploadsDir = path.join(__dirname, '../../uploads/presets');
    if (!fs.existsSync(uploadsDir)) {
      fs.mkdirSync(uploadsDir, { recursive: true });
    }
    
    // 构造唯一文件名
    const uniqueFilename = `${Date.now()}-${req.file.originalname}`;
    const filePath = path.join(uploadsDir, uniqueFilename);
    
    // 移动临时文件到上传目录
    fs.renameSync(req.file.path, filePath);
    
    // 保存文件信息到数据库
    const presetFile = await db.PresetFile.create({
      name,
      description: description || '',
      category: category || '其他',
      originalFilename: req.file.originalname,
      filePath: `uploads/presets/${uniqueFilename}`,
      fileType,
      fileSize: req.file.size,
      mimeType: req.file.mimetype,
      isActive: true,
      createdBy: req.user.id
    });
    
    // 获取创建者信息
    const creator = await db.User.findByPk(req.user.id, {
      attributes: ['id', 'username', 'fullName']
    });
    
    // 预设文件信息
    const responseData = {
      ...presetFile.toJSON(),
      creator: creator
    };
    
    res.status(201).json({
      success: true,
      message: '预设文件上传成功',
      presetFile: responseData
    });
  } catch (error) {
    console.error('上传预设文件出错:', error);
    
    // 如果文件已上传，删除临时文件
    if (req.file && req.file.path && fs.existsSync(req.file.path)) {
      fs.unlinkSync(req.file.path);
    }
    
    res.status(500).json({ message: '服务器内部错误', error: error.message });
  }
};

/**
 * 更新预设文件信息
 */
exports.updatePresetFile = async (req, res) => {
  try {
    const { id } = req.params;
    const { name, description, isActive } = req.body;
    
    const presetFile = await PresetFile.findByPk(id);
    
    if (!presetFile) {
      return res.status(404).json({ message: '预设文件不存在' });
    }
    
    // 更新文件信息
    await presetFile.update({
      name: name !== undefined ? name : presetFile.name,
      description: description !== undefined ? description : presetFile.description,
      isActive: isActive !== undefined ? isActive : presetFile.isActive
    });
    
    res.json({
      success: true,
      message: '预设文件信息已更新',
      presetFile
    });
  } catch (error) {
    console.error('更新预设文件信息出错:', error);
    res.status(500).json({ message: '服务器内部错误', error: error.message });
  }
};

/**
 * 删除预设文件
 */
exports.deletePresetFile = async (req, res) => {
  try {
    const { id } = req.params;
    
    // 获取数据库对象
    const db = req.app.get('db');
    
    // 如果数据库模型不可用，返回404
    if (!db || !db.PresetFile) {
      console.error('数据库模型不可用');
      return res.status(404).json({ message: '预设文件不存在' });
    }
    
    const presetFile = await db.PresetFile.findByPk(id);
    
    if (!presetFile) {
      return res.status(404).json({ message: '预设文件不存在' });
    }
    
    // 获取文件完整路径
    const filePath = path.join(__dirname, '../../', presetFile.filePath);
    
    // 如果文件存在，删除文件
    if (fs.existsSync(filePath)) {
      fs.unlinkSync(filePath);
    }
    
    // 从数据库中删除记录
    await presetFile.destroy();
    
    res.json({
      success: true,
      message: '预设文件已删除'
    });
  } catch (error) {
    console.error('删除预设文件出错:', error);
    res.status(500).json({ message: '服务器内部错误', error: error.message });
  }
};

/**
 * 下载预设文件
 */
exports.downloadPresetFile = async (req, res) => {
  try {
    const { id } = req.params;
    
    // 获取数据库对象
    const db = req.app.get('db');
    
    // 如果数据库模型不可用，返回404
    if (!db || !db.PresetFile) {
      console.error('数据库模型不可用');
      return res.status(404).json({ message: '预设文件不存在' });
    }
    
    const presetFile = await db.PresetFile.findByPk(id);
    
    if (!presetFile) {
      return res.status(404).json({ message: '预设文件不存在' });
    }
    
    // 获取文件完整路径
    const filePath = path.join(__dirname, '../../', presetFile.filePath);
    
    // 检查文件是否存在
    if (!fs.existsSync(filePath)) {
      return res.status(404).json({ message: '文件不存在或已被删除' });
    }
    
    // 设置文件名
    const fileName = path.basename(presetFile.filePath);
    
    // 设置响应头
    res.setHeader('Content-Disposition', `attachment; filename="${fileName}"`);
    res.setHeader('Content-Type', presetFile.mimeType || 'application/octet-stream');
    
    // 创建文件读取流并管道传输到响应
    const fileStream = fs.createReadStream(filePath);
    fileStream.pipe(res);
  } catch (error) {
    console.error('下载预设文件出错:', error);
    res.status(500).json({ message: '服务器内部错误', error: error.message });
  }
};

/**
 * 获取预设文件类型统计
 */
exports.getPresetFileStats = async (req, res) => {
  try {
    const stats = await PresetFile.findAll({
      attributes: [
        'fileType',
        [sequelize.fn('COUNT', sequelize.col('id')), 'count']
      ],
      group: ['fileType']
    });
    
    // 获取总文件数
    const totalFiles = await PresetFile.count();
    
    // 获取活跃文件数
    const activeFiles = await PresetFile.count({
      where: { isActive: true }
    });
    
    // 获取不活跃文件数
    const inactiveFiles = await PresetFile.count({
      where: { isActive: false }
    });
    
    res.json({
      typeStats: stats,
      total: totalFiles,
      active: activeFiles,
      inactive: inactiveFiles
    });
  } catch (error) {
    console.error('获取预设文件统计出错:', error);
    res.status(500).json({ message: '服务器内部错误', error: error.message });
  }
}; 